home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / Manager.C < prev    next >
C/C++ Source or Header  |  1992-08-24  |  12KB  |  650 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "Manager.h"
  6.  
  7. #include "Class.h"
  8. #include "Application.h"
  9. #include "Window.h"
  10. #include "String.h"
  11. #include "TextItem.h"
  12. #include "CommandProcessor.h"
  13. #include "WindowSystem.h"
  14. #include "Env.h"
  15. #include "OrdColl.h"
  16. #include "Expander.h"
  17. #include "MenuBar.h"
  18. #include "CmdNo.h"
  19. #include "Fields.h"
  20. #include "Menu.h"
  21. #include "View.h"
  22. #include "StreamConnection.h"
  23. #include "Application.h"
  24.  
  25. //---- Manager -----------------------------------------------------------------
  26.  
  27. NewAbstractMetaImpl(Manager,EvtHandler, (TP(name), TP(managers), TP(nextManager), TP(menubar),
  28.                 TP(menu), TP(firstHandler), TP(window), TE(wtype), TP(cmdp)));
  29.  
  30. Manager::Manager(char *t, MgrDismiss d, WindowType wt)
  31. {
  32.     Init(0, t, d, wt);
  33. }
  34.  
  35. Manager::Manager(Manager *nm, char *t, MgrDismiss d, WindowType wt)
  36. {
  37.     Init(nm, t, d, wt);
  38. }
  39.  
  40. void Manager::Init(Manager *nm, char *t, MgrDismiss d, WindowType wt)
  41. {
  42.     managers= 0;
  43.     menu= 0;
  44.     tvo= 0;
  45.     window= 0;
  46.     wtype= wt;
  47.     wflags= eWinDefault;
  48.     //if (nm == 0)
  49.     //    nm= gApplication;
  50.     nextManager= nm;
  51.     cmdp= 0;
  52.     menubar= 0;
  53.     name= 0;
  54.     firstHandler= 0;
  55.     dismiss= d;
  56.  
  57.     SetName(t);
  58. }
  59.  
  60. Manager::~Manager()
  61. {
  62.     firstHandler= 0;
  63.     if (nextManager) {
  64.     if (nextManager->managers)
  65.         nextManager->managers->RemovePtr(this);
  66.     nextManager= 0;
  67.     }
  68.     SafeDelete(tvo);
  69.     SafeDelete(cmdp);
  70.     SafeDelete(menu);
  71.     SafeDelete(window);
  72.     SafeDelete(name);
  73.     if (managers) {
  74.     OrdCollection *tmp= managers;
  75.     managers= 0;
  76.     tmp->FreeAll();
  77.     delete tmp;
  78.     }
  79. }
  80.  
  81. Point Manager::GetInitialPos(Point)
  82. {
  83.     return gPoint0;
  84. }
  85.  
  86. Point Manager::GetInitialWindowPos()
  87. {
  88.     if (nextManager)
  89.     return nextManager->GetInitialWindowPos();
  90.     return gPoint0;
  91. }
  92.  
  93. Point Manager::GetInitialWindowSize()
  94. {
  95.     return Point(500, 600);
  96. }
  97.  
  98. void Manager::SetName(char *nm)
  99. {
  100.     if (nm) {
  101.     strreplace(&name, nm);
  102.     SetWindowTitle(name);
  103.     }
  104. }
  105.  
  106. char *Manager::GetName()
  107. {
  108.     return name;
  109. }
  110.  
  111. int Manager::UniqueId()
  112. {
  113.     return 0;
  114. }
  115.  
  116. bool Manager::IsEqual(Object *op)
  117. {
  118.     if (op->IsKindOf(Manager))
  119.     return UniqueId() == ((Manager*)op)->UniqueId();
  120.     return FALSE;
  121. }
  122.  
  123. CommandProcessor *Manager::GetCmdP()
  124. {
  125.     return cmdp ? cmdp : (cmdp= MakeCmdProcessor());
  126. }
  127.  
  128. void Manager::ClearCmdProcessor()
  129. {
  130.     cmdp= 0;
  131. }
  132.  
  133. CommandProcessor *Manager::MakeCmdProcessor()
  134. {
  135.     return new CommandProcessor1;
  136. }
  137.  
  138. bool Manager::IsOpen()
  139. {
  140.     if (window)
  141.     return window->IsOpen();
  142.     return FALSE;
  143. }
  144.  
  145. void Manager::OpenAt(VObject *fp, Point p, bool resize, bool block)
  146. {
  147.     MakeWindows();
  148.     if (window)
  149.     window->OpenAt(p, fp, resize, block);
  150. }
  151.  
  152. int Manager::Run()
  153. {
  154.     return 0;
  155. }
  156.  
  157. void Manager::Open()
  158. {
  159.     OpenAt(0, GetInitialWindowPos(), FALSE);
  160. }
  161.  
  162. bool Manager::Close()   // return TRUE if OK
  163. {
  164. //    if (IsOpen()) {
  165.     Manager *mp;
  166.     Iter next(MakeIterator());
  167.     
  168.     while (mp= (Manager*) next()) // try to close all managers
  169.         if (! mp->Close())
  170.         return FALSE;
  171.  
  172.     if (window)
  173.         window->Close();
  174.     if (nextManager)
  175.         nextManager->RemoveManager(this);
  176. //    } 
  177.     return TRUE;
  178. }
  179.  
  180. void Manager::Show()
  181. {
  182.     if (window == 0)
  183.     Open();
  184.     else
  185.     window->Open();
  186.     if (managers) {
  187.     managers->ForEach(Manager,Show)();
  188.     }
  189. }
  190.  
  191. void Manager::Hide()
  192. {
  193.     if (managers) {
  194.     managers->ForEach(Manager,Hide)();
  195.     }
  196.     if (window)
  197.     window->Close();
  198. }
  199.  
  200. bool Manager::AboutToDismiss()
  201. {
  202.     if (firstHandler) {
  203.     bool rc= firstHandler->KbdFocus(FALSE);
  204.     if (!rc)
  205.         return FALSE;
  206.     firstHandler->KbdFocus(TRUE);
  207.     }
  208.     return TRUE;
  209. }
  210.  
  211. bool Manager::Dismiss()
  212. {
  213.     if (!AboutToDismiss())
  214.     return FALSE;
  215.     switch (dismiss) {
  216.     case eMgrClose:
  217.     return Close();
  218.  
  219.     case eMgrHide:
  220.     Hide();
  221.     return TRUE;
  222.     
  223.     case eMgrIconize:
  224.     Iconize();
  225.     return TRUE;
  226.     }
  227. }
  228.  
  229. void Manager::Iconize()
  230. {
  231.     if (window)
  232.     window->Iconize();
  233. }
  234.  
  235. void Manager::AddManager(Manager *mp)
  236. {
  237.     if (mp) {
  238.     if (managers == 0)
  239.         managers= new OrdCollection;
  240.     else
  241.         managers->RemovePtr(mp);
  242.     managers->Add(mp);
  243.     mp->SetNextManager(this);
  244.     }
  245. }
  246.  
  247. Iterator *Manager::MakeIterator()
  248. {
  249.     if (managers)
  250.     return managers->MakeIterator();
  251.     return new Iterator0;
  252. }
  253.  
  254. int Manager::Size()
  255. {
  256.     if (managers)
  257.     return managers->Size();
  258.     return 0;
  259. }
  260.  
  261. Manager *Manager::FindManager(int id)
  262. {
  263.     Manager *dp;
  264.     Iter next(MakeIterator());
  265.     
  266.     while (dp= (Manager*) next())
  267.     if (dp->UniqueId() == id)
  268.         return dp;
  269.     return 0;
  270. }
  271.  
  272. void Manager::RemoveManager(Manager *mp)
  273. {
  274.     if (gSystem && managers && managers->RemovePtr(mp))
  275.     gSystem->AddCleanupObject(mp);
  276. }
  277.  
  278. void Manager::SetNextManager(Manager *mp)
  279. {
  280.     nextManager= mp;
  281. }
  282.  
  283. EvtHandler *Manager::GetNextHandler()
  284. {
  285.     return nextManager;
  286. }
  287.  
  288. void Manager::MakeWindows()
  289. {
  290.     if (window == 0) {
  291.     window= DoMakeWindows();
  292.     if (window)
  293.         window->SetNextManager(this);
  294.     SetWindowTitle(GetName());
  295.     }
  296. }
  297.  
  298. Window *Manager::GetWindow()
  299. {
  300.     return window;
  301. }
  302.  
  303. VObject *Manager::DoMakeContent()
  304. {
  305.     return 0;
  306. }
  307.  
  308. VObject *Manager::DoMakeIconContent()
  309. {
  310.     return 0;
  311. }
  312.  
  313. Window *Manager::DoMakeWindows()
  314. {
  315.     VObject *inner= DoMakeContent();
  316.     if (inner) {
  317.     menubar= DoMakeMenuBar();
  318.     if (menubar)
  319.         inner= new Expander(cIdNone, eVert, gPoint2, menubar, inner, 0);
  320.     return new Window(this, inner, wtype, wflags, GetInitialWindowSize(), GetName());
  321.     }
  322.     return 0;
  323. }
  324.  
  325. MenuBar *Manager::GetMenuBar()
  326. {
  327.     return menubar;
  328. }
  329.  
  330. void Manager::SetWindowTitle(char *t)
  331. {
  332.     if (window)
  333.     window->SetTitle(t);
  334. }
  335.  
  336. void Manager::SetOnDismiss(MgrDismiss d)
  337. {
  338.     dismiss= d;
  339. }
  340.  
  341. //---- Menus -------------------------------------------------------------------
  342.  
  343. Menu *Manager::GetMenu()
  344. {
  345.     if (menu == 0) {
  346.     menu= new Menu(cEDITMENU, "Edit");
  347.     GetCmdP()->DoCreateMenu(menu);
  348.     menu->AppendItems(  "-",
  349.                 "Cut@X",  cCUT,
  350.                 "Copy@C", cCOPY,
  351.                 "Paste@V",cPASTE,
  352.                 0);
  353.     }
  354.     return menu;
  355. }
  356.  
  357. Menu *Manager::MakeMenu(int menuId)
  358. {
  359.     Menu *m= 0;
  360.     
  361.     switch (menuId) {
  362.     case cHELPMENU:
  363.     m= new Menu(cHELPMENU, "Help", FALSE);
  364.     m->AppendItem("About", cABOUT);
  365.     m->AppendItem("Help",  cHELP);
  366.     break;
  367.     
  368.     case cMANAGERMENU:
  369.     m= new Menu(cMANAGERMENU, "File");
  370.     m->AppendItems( 
  371.             "New@N",      cNEW,
  372.             "-",
  373.             "Close",      cCLOSE,
  374.             "Print ...@P",cPRINT,
  375.             "-",
  376.             "Quit@Q",     cQUIT,
  377.             0);
  378.     break;
  379.  
  380.     case cTOOLMENU:
  381.     m= new Menu(cTOOLMENU, "Tool", FALSE);
  382.     m->AppendItem("Close", cCLOSE);
  383.     break;
  384.     
  385.     case cEDITMENU:
  386.     m= new Menu(cEDITMENU, "Edit");
  387.     GetCmdP()->DoCreateMenu(m);
  388.     m->AppendItems("-",
  389.               "Cut@X",          cCUT,
  390.               "Copy@C",         cCOPY,
  391.               "Paste@V",        cPASTE,
  392.               "Paste File ...", cIMPORT,
  393.               "Clear",          cCLEAR,
  394.               "-",
  395.               "Select All@A",   cSELECTALL,
  396.               0);
  397.     break;
  398.     
  399.     default:
  400.     if (nextManager)
  401.         m= nextManager->MakeMenu(menuId);
  402.     }
  403.     return m;
  404. }
  405.  
  406. MenuBar *Manager::DoMakeMenuBar()
  407. {
  408.     MenuBar *mb= new MenuBar;
  409.     
  410.     mb->AddMenu(MakeMenu(cHELPMENU));
  411.     mb->AddMenu(MakeMenu(cTOOLMENU));
  412.     mb->AddMenu(MakeMenu(cEDITMENU));
  413.     return mb;
  414. }
  415.  
  416. void Manager::DoSetupMenu(Menu *menu)
  417. {
  418.     EvtHandler::DoSetupMenu(menu);
  419.     if (menu->GetId() == cEDITMENU)
  420.     GetCmdP()->DoSetupMenu(menu);
  421.     menu->EnableItems(cNEW, cCLOSE, cPRINT, 0);
  422. }
  423.  
  424. Command *Manager::DoMenuCommand(int cmd)
  425. {
  426.     switch(cmd) {
  427.     case cCLOSE:
  428.     Dismiss();
  429.     break;
  430.     case cCOLLAPSE:
  431.     Iconize();
  432.     break;
  433.     case cUNDO:
  434.     case cREDO:
  435.     GetCmdP()->DoMenuCommand(cmd);
  436.     break;
  437.     case cHELP:
  438.     gRpc->Talk("help", "show %s", ClassName());
  439.     break;
  440.     default:
  441.     return EvtHandler::DoMenuCommand(cmd);
  442.     }
  443.     return gNoChanges;
  444. }
  445.  
  446. void Manager::Control(int id, int part, void *vp)
  447. {
  448.     switch (id) {
  449.     case cCLOSE:
  450.     Dismiss();
  451.     break; 
  452.     case cCOLLAPSE:
  453.     Iconize();
  454.     break;
  455.     case cHELP:
  456.     gRpc->Talk("help", "show %s", ClassName());
  457.     break;
  458.     default:
  459.     EvtHandler::Control(id, part, vp);
  460.     break;
  461.     }
  462. }
  463.  
  464. void Manager::ExtCommand(int, char *req, char*, int, char *&, int &)
  465. {
  466.     if (strcmp(req, "close") == 0)
  467.     Close();
  468.     else if (strcmp(req, "iconize") == 0)
  469.     Iconize();
  470.     else if (strcmp(req, "show") == 0)
  471.     Show();
  472. }
  473.  
  474. void Manager::InputKbd(Token &t)
  475. {
  476.     int cmd= cIdNone;
  477.     Command *cp= 0;
  478.  
  479.     if (t.IsKey() && t.Code == '\r' && GetDefaultButton()) {
  480.     if (AboutToDismiss())
  481.         GetDefaultButton()->Flush();
  482.     return;
  483.     }
  484.     if (t.Flags & eFlgMetaKey) {
  485.     int c= t.Code & 0x7f;
  486.     if (menu)
  487.         cmd= menu->CheckKey(t);
  488.     if (menubar && cmd == cIdNone)
  489.         cmd= menubar->CheckKey(t);
  490.     if (cmd != cIdNone) {
  491.         if (firstHandler)
  492.         cp= firstHandler->DoMenuCommand(cmd);
  493.     } else if (window)
  494.         window->Bell();
  495.     } else if (cp == 0 && firstHandler)
  496.     cp= firstHandler->Input(t.Pos, t, window);
  497.     if (cp)
  498.     PerformCommand(cp);
  499. }
  500.  
  501. void Manager::SetFirstHandler(EvtHandler *focus)
  502. {
  503.     if (focus != firstHandler) {
  504.     int acceptfocus= TRUE;
  505.     int isactive= (gFirstHandler == firstHandler);
  506.  
  507.     if (firstHandler)
  508.         acceptfocus= firstHandler->KbdFocus(FALSE);
  509.         
  510.     if (acceptfocus) {
  511.         firstHandler= 0;
  512.         if (focus) {
  513.             acceptfocus= focus->KbdFocus(TRUE);        
  514.             if (acceptfocus)
  515.             firstHandler= focus;
  516.         }
  517.     }
  518.     
  519.     if (isactive)
  520.         gFirstHandler= firstHandler;
  521.     }
  522. }
  523.  
  524. void Manager::SetActive(bool active)
  525. {
  526.     if (active)
  527.     gFirstHandler= firstHandler;
  528.     /* else
  529.     gFirstHandler= 0; */
  530.     /*
  531.     if (gFirstHandler && gFirstHandler->IsKindOf(View))
  532.     ((View*)gFirstHandler)->ShowSelection(FALSE, active);
  533.     */
  534. }
  535.  
  536. TextViewOverlay *Manager::GetTextViewOverlay()
  537. {
  538.     if (tvo == 0)
  539.     tvo= new TextViewOverlay;
  540.     return tvo;
  541. }
  542.  
  543. void Manager::SendDown(int id, int part, void *val)
  544. {
  545.     if (managers) {
  546.     Iter next(managers);
  547.     Manager *m;
  548.     while (m= (Manager*) next())
  549.         m->SendDown(id, part, val);
  550.     }
  551. }
  552.  
  553. void Manager::PerformCommand(Command *cmd)
  554. {
  555.     GetCmdP()->PerformCommand(cmd);
  556. }
  557.  
  558. //---- Default Button ----------------------------------------------------------
  559.  
  560. static bool FindDfltButton(Object*, Object *op, void *vp)
  561. {
  562.     VObject *vop= (VObject*) op;
  563.     if (vop->IsKindOf(ActionButton) && vop->TestFlag(eActionDefaultButton)
  564.                 && vop->Enabled() /* && vop->IsOpen() */) {
  565.     *((Button**) vp)= (ActionButton*) vop;
  566.     return TRUE;
  567.     }
  568.     return FALSE;
  569. }
  570.  
  571. Button *Manager::GetDefaultButton()
  572. {
  573.     Button *dfltButton= 0;
  574.     if (window->GetViewedVObject())
  575.     window->GetViewedVObject()->Detect(FindDfltButton, &dfltButton);
  576.     return dfltButton;
  577. }
  578.  
  579. //---- Focus -------------------------------------------------------------------
  580.  
  581. struct FindFocus {
  582.     EvtHandler *focus;
  583.     VObject *first, *last, *prev, *next;
  584.     bool found;
  585.     
  586.     FindFocus(EvtHandler *f)
  587.     { first= last= prev= next= 0; found= FALSE; focus= f; }
  588. };
  589.     
  590. static bool FindFocusItem(Object*, Object *op, void *vp)
  591. {
  592.     register FindFocus *ff= (FindFocus*) vp;
  593.     VObject *vop= (VObject*) op;
  594.  
  595.     if (vop->WantsKbdFocus() && vop->Enabled() /* && vop->IsOpen() */) {
  596.     if (ff->first == 0)
  597.         ff->first= vop;
  598.     if (ff->found && ff->next == 0)
  599.         ff->next= vop;
  600.     if (vop == ff->focus)
  601.         ff->found= TRUE;
  602.     if (! ff->found)
  603.         ff->prev= vop;
  604.     ff->last= vop;
  605.     }
  606.     return FALSE;
  607. }
  608.  
  609. void Manager::TabFields(Token &t)
  610. {
  611.     FindFocus ff(firstHandler);
  612.     
  613.     window->GetViewedVObject()->Detect(FindFocusItem, &ff);
  614.     if (ff.prev == 0)
  615.     ff.prev= ff.last;
  616.     if (ff.next == 0)
  617.     ff.next= ff.first;
  618.     
  619.     if (firstHandler == 0) // take the first enabled item
  620.     SetFirstHandler(ff.first);
  621.     else if (t.Flags & eFlgShiftKey)
  622.     SetFirstHandler(ff.prev);
  623.     else
  624.     SetFirstHandler(ff.next);
  625. }
  626.  
  627. //---- Inspector ---------------------------------------------------------------
  628.  
  629. void Manager::CollectParts(Collection* col)
  630. {
  631.     EvtHandler::CollectParts(col);
  632.     if (menu)
  633.     col->Add(menu);
  634.     if (cmdp)
  635.     col->Add(cmdp);
  636.     if (managers)
  637.     col->Add(managers);
  638.     if (window)
  639.     col->Add(window);
  640. }
  641.  
  642. void Manager::InspectorId(char *buf, int bufSize)
  643. {
  644.     if (GetName())
  645.     strn0cpy(buf, GetName(), bufSize);
  646.     else
  647.     strn0cpy(buf, "Unamed", bufSize);
  648. }
  649.  
  650.